home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / SummaryLists.c < prev    next >
C/C++ Source or Header  |  1996-05-04  |  15KB  |  613 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *      RSysSummaryLists.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    void MakeHardwareList ( void );
  12.    *    void MakeMemoryList ( void );
  13.    *    void MakeSystemList ( void );
  14.    *
  15.    *      --- Lokale  Routinen ---
  16.    *
  17.    *    static RSYS_hardwareentry *allocentry ( RSYS_hardwareentry *prev , char *title , char *info );
  18.    *    static RSYS_hardwareentry *allochardwareentry ( RSYS_hardwareentry *prev , char *title , char *info );
  19.    *    static RSYS_hardwareentry *allocnumhardwareentry ( RSYS_hardwareentry *prev , char *title , unsigned long num , int hex );
  20.    *    static void CheckProcessors ( char *cpu , char *fpu , char *mmu );
  21.    *    static void extract_comp ( UWORD manufactnr , UWORD prodnr , char *name , char *company , int type );
  22.    *
  23.    * Bemerkungen:
  24.    *      Listen für Hardwarekonfiguration, Speicherlisten und Systemliste.
  25.    *
  26.    * Erstellungsdatum:
  27.    *      25-Jun-93     Rolf Böhme
  28.    *
  29.    * Änderungen:
  30.    *      25-Jun-93     Rolf Böhme        Erstellung
  31.    *
  32.    ***************************************************************************
  33.  */
  34.  
  35. #include "RSys.h"
  36. #include "protos.h"
  37.  
  38.  
  39. static RSYS_hardwareentry firsthardwareentry =
  40.  
  41. {
  42.   "", "", NULL
  43. };
  44.  
  45. static REMEMBER *Key = NULL;
  46.  
  47.  /*
  48.   * allochardwareentry() erzeugt einen Eintrag für die
  49.   * Hardwareliste
  50.   */
  51. static RSYS_hardwareentry *
  52. allochardwareentry (RSYS_hardwareentry * prev, char *title, char *info)
  53. {
  54.   RSYS_hardwareentry *new;
  55.  
  56.   if (new = (RSYS_hardwareentry *) AllocRemember ((REMEMBER **) & Key,
  57.                         sizeof (RSYS_hardwareentry),
  58.                           MEMF_CLEAR))
  59.     {
  60.       if (title)
  61.     strncpy (new->title, title, TITLELEN);
  62.       else
  63.     strcpy (new->title, field[BLANK_FIELD]);
  64.  
  65.       if (info)
  66.     strncpy (new->info, info, MAXSTRLEN);
  67.       else
  68.     new->info[0] = STRINGEND;
  69.  
  70.       prev->next = new;
  71.  
  72.       new->next = NULL;
  73.     }
  74.   else
  75.     ErrorHandle (title, MEMORY_ERR, ALLOC_FAIL, KILL);
  76.  
  77.   return new;
  78. }
  79.  
  80.  /*
  81.   * allochardwareentry() erzeugt einen Eintrag für die
  82.   * Hardwareliste
  83.   */
  84. static RSYS_hardwareentry *
  85. allocentry (RSYS_hardwareentry * prev, char *title, char *info)
  86. {
  87.   RSYS_hardwareentry *new;
  88.  
  89.   if (new = (RSYS_hardwareentry *) AllocRemember ((REMEMBER **) & Key,
  90.                         sizeof (RSYS_hardwareentry),
  91.                           MEMF_CLEAR))
  92.     {
  93.       strncpy (new->title, title, TITLELEN);
  94.  
  95.       if (info)
  96.     strncpy (new->info, info, MAXSTRLEN);
  97.       else
  98.     strcpy (new->info, "-");
  99.  
  100.       prev->next = new;
  101.  
  102.       new->next = NULL;
  103.     }
  104.   else
  105.     ErrorHandle (title, MEMORY_ERR, ALLOC_FAIL, KILL);
  106.  
  107.   return new;
  108. }
  109.  
  110.  /*
  111.   * allocnumhardwareentry() erzeugt einen Zahleneintrag für die
  112.   * Hardwareliste
  113.   */
  114. static RSYS_hardwareentry *
  115. allocnumhardwareentry (RSYS_hardwareentry * prev, char *title,
  116.                unsigned long num, int hex)
  117. {
  118.   RSYS_hardwareentry *new;
  119.  
  120.   if (new = (RSYS_hardwareentry *) AllocRemember ((REMEMBER **) & Key,
  121.                         sizeof (RSYS_hardwareentry),
  122.                           MEMF_CLEAR))
  123.     {
  124.       strncpy (new->title, title, TITLELEN);
  125.  
  126.       if (hex)
  127.     sprintf (new->info, "0x%08lX", num);
  128.       else
  129.     sprintf (new->info, "%ld", num);
  130.  
  131.       prev->next = new;
  132.  
  133.       new->next = NULL;
  134.     }
  135.   else
  136.     ErrorHandle (title, MEMORY_ERR, ALLOC_FAIL, KILL);
  137.  
  138.   return new;
  139. }
  140.  
  141.  
  142.  /*
  143.   * extract_comp() ermittelt einen Company-Namen und einen
  144.   * Produktnamen aus dem Manufacturer-Eintrag in der
  145.   * ExpansionBase
  146.   */
  147. static void
  148. extract_comp (UWORD manufactnr, UWORD prodnr, char *name, char *company, int type)
  149. {
  150.   int i, j;
  151.  
  152.   strcpy (company, field[UNKNOWN_FIELD]);
  153.   strcpy (name, field[UNKNOWN_FIELD]);
  154.   type = -1;
  155.  
  156.   if (Flags.dummy1 == 0)
  157.     return;
  158.  
  159.   for (i = 0; i < hardwarecnt; i++)
  160.     if (manu[i].manu_nr == manufactnr)
  161.       {
  162.     strncpy (company, company_str[manu[i].company], BUFSIZE);
  163.  
  164.     j = i;
  165.     while ((manu[j].prod_nr != prodnr) && (manu[j].manu_nr == manufactnr))
  166.       j++;
  167.  
  168.     if ((manu[j].prod_nr == prodnr) && (manu[j].manu_nr == manufactnr))
  169.       {
  170.         type = manu[j].type_nr;
  171.         strncpy (name, manu[j].name, BUFSIZE);
  172.       }
  173.  
  174.     break;
  175.       }
  176.  
  177.   return;
  178. }
  179.  
  180.  
  181.  /*
  182.   * CheckProcessors() prüft den Type der CPU, MMU und der FPU
  183.   * mit ein paar kleinen Assemblerroutinen, die ich aus dem
  184.   * Quelltext des Programmes SetCPU von D. Haynie geratzt habe
  185.   */
  186. static void
  187. CheckProcessors (char *cpu, char *fpu, char *mmu)
  188. {
  189.   ULONG _cpu = GetCPUType ();
  190.   ULONG _fpu = GetFPUType ();
  191.   ULONG _mmu = GetMMUType ();
  192.  
  193.   sprintf (cpu, "CPU %ld", _cpu);
  194.  
  195.   if (_fpu != 0L)
  196.     sprintf (fpu, "FPU %ld", _fpu);
  197.   else
  198.     strcpy (fpu, "None");
  199.  
  200.   if (_mmu != 0L)
  201.     sprintf (mmu, "MMU %ld", _mmu);
  202.   else
  203.     strcpy (mmu, "None");
  204.  
  205.   return;
  206. }
  207.  
  208.  /*
  209.   * MakeHardwareList() erzeugt eine Anzeigeliste mit den
  210.   * Daten der Hardware-Ausstattung des Rechners, auf dem RSys
  211.   * läuft
  212.   */
  213. void
  214. MakeHardwareList (void)
  215. {
  216.   RSYS_hardwareentry *loop;
  217.   int count = 0, i;
  218. /*
  219.    GMD
  220.  
  221.    UWORD type = SysBase->AttnFlags;
  222.  */
  223.   char out[BUFSIZE], comp[BUFSIZE], name[BUFSIZE], *titles[] =
  224.   {
  225.   /* 0 */ "Processor",
  226.   /* 1 */ "Coprocessor",
  227.   /* 2 */ "Memory Unit",
  228.   /* 3 */ "Denise",
  229.   /* 4 */ "Agnus",
  230.   /* 5 */ "Type",
  231.   /* 6 */ "Company",
  232.   /* 7 */ "Name",
  233.   /* 8 */ "Init Action",
  234.   /* 9 */ "Driver",
  235.   /* 10 */ "Priority",
  236.   /* 11 */ "Diagnosis",
  237.   /* 12 */ "Manuf   #",
  238.   /* 13 */ "Product #",
  239.   /* 14 */ "Serial",
  240.   /* 15 */ "Board addr",
  241.   /* 16 */ "Board size",
  242.   /* 17 */ "Slot  addr",
  243.   /* 18 */ "Slot  size",
  244.   /* 19 */ "           >",
  245.   /* 20 */ "Alice",
  246.   /* 21 */ "Lisa",
  247.   /* 22 */ "MLisa",
  248.   /* 23 */ "Chipset",
  249.   /* 24 */ "Manuf type"
  250.   };
  251.  
  252.   char cpu[3][10];
  253.   CONFIGDEV *lastboard = NULL;
  254.   EXPANSIONROM *expansionrom;
  255.  
  256. /* GMD */
  257.   int manutype = -1;        /*GMD */
  258.  
  259.   NODE *devnode;
  260.  
  261.   DPOS;
  262.  
  263.   loop = allochardwareentry (&firsthardwareentry,
  264.               "------------------------------- Hardware", NULL);
  265.  
  266.   CheckProcessors (cpu[0], cpu[1], cpu[2]);
  267.  
  268.   for (i = 0; i < 3; i++)
  269.     loop = allochardwareentry (loop, titles[i], cpu[i]);
  270.  
  271.   if (GfxBase->ChipRevBits0 & GFXF_HR_DENISE)
  272.     loop = allochardwareentry (loop, titles[3], "ECS-Denise (8373)");
  273.   else
  274.     loop = allochardwareentry (loop, titles[3], "Normal Denise (8362)");
  275.  
  276.   if (GfxBase->ChipRevBits0 & GFXF_HR_AGNUS)
  277.     loop = allochardwareentry (loop, titles[4], "ECS-Agnus (8372)");
  278.   else
  279.     loop = allochardwareentry (loop, titles[4], "Normal Agnus");
  280.  
  281.   count += 6;
  282.  
  283.   if (GfxBase->ChipRevBits0 & (GFXF_AA_ALICE | GFXF_AA_LISA | GFXF_AA_MLISA))
  284.     {
  285.       if (GfxBase->ChipRevBits0 & GFXF_AA_ALICE)
  286.     loop = allochardwareentry (loop, titles[20], "AA-Alice");
  287.       else
  288.     loop = allochardwareentry (loop, titles[20], "Non AA-Alice");
  289.  
  290.       if (GfxBase->ChipRevBits0 & GFXF_AA_LISA)
  291.     loop = allochardwareentry (loop, titles[21], "AA-Lisa");
  292.       else
  293.     loop = allochardwareentry (loop, titles[21], "Non AA-Lisa");
  294.  
  295.       if (GfxBase->ChipRevBits0 & GFXF_AA_MLISA)
  296.     loop = allochardwareentry (loop, titles[22], "AA-MLisa");
  297.       else
  298.     loop = allochardwareentry (loop, titles[22], "Non AA-MLisa");
  299.  
  300.       count += 3;
  301.     }
  302.   else
  303.     {
  304.       loop = allochardwareentry (loop, titles[23], "No AA-Chipset");
  305.       count++;
  306.     }
  307.  
  308.   loop = allochardwareentry (loop, (char *) field[BLANK_FIELD], NULL);
  309.  
  310.   count += 2;
  311.  
  312.   if (ExpansionBase = (EXPANSIONBASE *) OpenLibrary ((UBYTE *) "expansion.library", NULL))
  313.     {
  314.       int cnt = 0;
  315.       int j = 0;
  316.  
  317.       while (lastboard = FindConfigDev (lastboard, -1L, -1L))
  318.     {
  319.       UBYTE buf[TITLELEN] =
  320.       "-------------------------------- Expansion Board ?";        /*GMD */
  321.  
  322.       buf[49] = '0' + j++;
  323.       loop = allochardwareentry (loop, buf, NULL);
  324.       expansionrom = &(lastboard->cd_Rom);
  325.       if (expansionrom->er_Type & ERTF_MEMLIST)
  326.         loop = allochardwareentry (loop, titles[5], "RAM Expansion");
  327.       else
  328.         loop = allochardwareentry (loop, titles[5], "Other Expansion");
  329.  
  330.       extract_comp (expansionrom->er_Manufacturer,
  331.             expansionrom->er_Product, name, comp, manutype);
  332.       loop = allochardwareentry (loop, titles[6], comp);
  333.       loop = allochardwareentry (loop, titles[7], name);
  334.  
  335.       count += 3;
  336.  
  337.       if (lastboard->cd_Flags & CDF_SHUTUP)
  338.         {
  339.           loop = allochardwareentry (loop, titles[8], "No active");
  340.           count++;
  341.         }
  342.  
  343.       if (lastboard->cd_Flags & CDF_CONFIGME)
  344.         {
  345.           loop = allochardwareentry (loop, titles[8], "Need Driver");
  346.           count++;
  347.         }
  348.  
  349.       if (lastboard->cd_Flags & CDF_BADMEMORY)
  350.         {
  351.           loop = allochardwareentry (loop, titles[19], "Contains bad memory");
  352.           count++;
  353.         }
  354.  
  355.       if (lastboard->cd_Flags & CDF_PROCESSED)
  356.         {
  357.           loop = allochardwareentry (loop, titles[19], "Private processed");
  358.           count++;
  359.         }
  360.  
  361.       if (devnode = (NODE *) lastboard->cd_Driver)
  362.         {
  363.           loop = allochardwareentry (loop, titles[9], devnode->ln_Name);
  364.           loop = allocnumhardwareentry (loop, titles[10],
  365.                         (unsigned long) devnode->ln_Pri,
  366.                         FALSE);
  367.           count += 2;
  368.         }
  369.  
  370.       if (expansionrom->er_Flags & ERTF_DIAGVALID)
  371.         loop = allochardwareentry (loop, titles[11], "Action attached");
  372.       else
  373.         loop = allochardwareentry (loop, titles[11], "No action attached");
  374.  
  375.       loop = allocnumhardwareentry (loop, titles[12],
  376.               (unsigned long) expansionrom->er_Manufacturer, FALSE);
  377.       loop = allocnumhardwareentry (loop, titles[13],
  378.                (unsigned long) expansionrom->er_Product, FALSE);
  379.       loop = allocnumhardwareentry (loop, titles[14],
  380.                (unsigned long) expansionrom->er_SerialNumber, TRUE);
  381.       loop = allocnumhardwareentry (loop, titles[24],
  382.                     (unsigned long) manutype, FALSE);
  383.       loop = allocnumhardwareentry (loop, titles[15],
  384.                  (unsigned long) lastboard->cd_BoardAddr, TRUE);
  385.       loop = allocnumhardwareentry (loop, titles[16],
  386.                 (unsigned long) lastboard->cd_BoardSize, FALSE);
  387.       loop = allocnumhardwareentry (loop, titles[17],
  388.                   (unsigned long) lastboard->cd_SlotAddr, TRUE);
  389.       loop = allocnumhardwareentry (loop, titles[18],
  390.                  (unsigned long) lastboard->cd_SlotSize, FALSE);
  391.  
  392.       loop = allochardwareentry (loop, (char *) field[BLANK_FIELD], NULL);
  393.  
  394.       count += 10;
  395.  
  396.       cnt++;
  397.     }
  398.  
  399.       sprintf (out, "%ld expansions found", cnt);
  400.       loop = allochardwareentry (loop, "Summary", out);
  401.       count++;
  402.  
  403.       CloseLibrary ((LIBRARY *) ExpansionBase);
  404.     }
  405.   else
  406.     ErrorHandle ("expansion.library", LIBRARY_ERR, OPEN_FAIL, NO_KILL);
  407.  
  408.   countentries = count;
  409.  
  410.   Entries = AllocScrollEntries (countentries);
  411.  
  412.   loop = firsthardwareentry.next;
  413.   i = 0;
  414.  
  415.   while (loop && (i < countentries))
  416.     {
  417.       if (loop->info[0])
  418.     sprintf (Entries[i].se_Entry, "%-13s : %s", loop->title, loop->info);
  419.       else
  420.     strncpy (Entries[i].se_Entry, loop->title, BUFSIZE);
  421.  
  422.       i++;
  423.  
  424.       loop = loop->next;
  425.     }
  426.  
  427.   FreeRemember ((REMEMBER **) & Key, TRUE);
  428.  
  429.   CreateEntryList (NO_SORT, 0);
  430.  
  431.   PrintInfo ("Hardwarelist read", SPEAK, 0);
  432.  
  433.   return;
  434. }
  435.  
  436.  /*
  437.   * MakeMemoryList() erzeugt eine Liste der Speichereinträge mit
  438.   * allen Fragmentierungen
  439.   */
  440. void
  441. MakeMemoryList (void)
  442. {
  443.   int i = 3;
  444.   MEMCHUNK *Loop;
  445.   MEMHEADER *MemHeader;
  446.   char cattype[MEMTYPELEN], type[5];
  447.   ULONG BlockSize = 0L, MemSize;
  448.  
  449.   DPOS;
  450.  
  451.   countentries = CountMemory () + 3;
  452.  
  453.   if (NoEntries ())
  454.     return;
  455.  
  456.   Entries = AllocScrollEntries (countentries);
  457.  
  458.   Forbid ();
  459.  
  460.   for (MemHeader = (MEMHEADER *) SysBase->MemList.lh_Head;
  461.        MemHeader->mh_Node.ln_Succ && (i < countentries);
  462.        MemHeader = (MEMHEADER *) MemHeader->mh_Node.ln_Succ)
  463.     {
  464.       MemSize = ((ULONG) MemHeader->mh_Upper - (ULONG) MemHeader->mh_Lower);
  465.       BlockSize += MemSize;
  466.  
  467.       if (MemHeader->mh_Attributes & MEMF_CHIP)
  468.     strcpy (type, "CHIP");
  469.       else if (MemHeader->mh_Attributes & MEMF_FAST)
  470.     strcpy (type, "FAST");
  471.       else
  472.     strcpy (type, field[NO_TYPE]);
  473.  
  474.       strncpy (cattype, type, MEMTYPELEN);
  475.  
  476.       Entries[i].se_obj_id.address = MemHeader;
  477.       sprintf (Entries[i].se_Entry, EntryAttr[MEMORY].ea_dataformat,
  478.            (ULONG) MemHeader, MemSize, type);
  479.  
  480.       i++;
  481.  
  482.       for (Loop = MemHeader->mh_First; Loop && (i < countentries);
  483.        Loop = Loop->mc_Next)
  484.     {
  485.       strncpy (cattype, type, MEMTYPELEN);
  486.       strcat (cattype, "-CHUNK");
  487.  
  488.       Entries[i].se_obj_id.address = Loop;
  489.       sprintf (Entries[i].se_Entry, EntryAttr[MEMORY].ea_dataformat,
  490.            (ULONG) Loop, Loop->mc_Bytes, cattype);
  491.       i++;
  492.     }
  493.     }
  494.  
  495.   Permit ();
  496.   {
  497.     /*GMD */
  498.     ULONG total = BlockSize / 1024;
  499.     ULONG fast = AvailMem (MEMF_FAST) / 1024;
  500.     ULONG chipx = AvailMem (MEMF_CHIP) / 1024;
  501.     ULONG fast_l = AvailMem (MEMF_FAST | MEMF_LARGEST) / 1024;
  502.     ULONG chip_l = AvailMem (MEMF_CHIP | MEMF_LARGEST) / 1024;
  503.  
  504.  
  505.     sprintf (Entries[0].se_Entry, "Total:    %6ldK CHIP:%5ldK FAST:%5ldK",
  506.          total, chipx, fast);
  507.  
  508.     sprintf (Entries[1].se_Entry, "Largest: %8s CHIP:%5ldK FAST:%5ldK",
  509.          field[BLANK_FIELD], chip_l, fast_l);
  510.   }
  511.   strcpy (Entries[2].se_Entry, "-------------- Fragmentation --------------");
  512.  
  513.   CreateEntryList (NO_SORT, 0);
  514.  
  515.   return;
  516. }
  517.  
  518.  /*
  519.   * MakeSystemList() gibt eine Kurzinfo über das laufende System
  520.   */
  521. void
  522. MakeSystemList (void)
  523. {
  524.   int count = 0;
  525.   long timeptr;
  526.   TM tm, *tmhelp = &tm;
  527.   int tasks, processes;
  528.   static UBYTE *xmonth[] =
  529.   {
  530.     "",
  531.     "Jan",
  532.     "Feb",
  533.     "Mar",
  534.     "Apr",
  535.     "May",
  536.     "Jun",
  537.     "Jul",
  538.     "Aug",
  539.     "Sep",
  540.     "Oct",
  541.     "Nov",
  542.     "Dec"
  543.   };
  544.  
  545.   DPOS;
  546.  
  547.   countentries = 10;
  548.   Entries = AllocScrollEntries (countentries);
  549.  
  550.   timeptr = time (NULL);
  551.   tmhelp = localtime ((time_t *) & timeptr);
  552.  
  553.   sprintf (Entries[count++].se_Entry,
  554.        "%02ld-%s-%ld, day = %3ld, week = %2ld",
  555.       tmhelp->tm_mday, xmonth[tmhelp->tm_mon + 1], (1900 + tmhelp->tm_year),
  556.        tmhelp->tm_yday + 1, (int) ((tmhelp->tm_yday + 1) / 7) + 1);
  557.  
  558.   /*
  559.    * GMD
  560.    */
  561.   sprintf (Entries[count++].se_Entry, "  ");    /* blank line */
  562.  
  563.   tasks = CountNodesType (&SysBase->TaskWait, NT_TASK) +
  564.     CountNodesType (&SysBase->TaskReady, NT_TASK);
  565.  
  566.   sprintf (Entries[count++].se_Entry, "Tasks       : %3ld", tasks);
  567.  
  568.  
  569.   processes = CountNodesType (&SysBase->TaskWait, NT_PROCESS) +
  570.     CountNodesType (&SysBase->TaskReady, NT_PROCESS) + 1;
  571.  
  572.   sprintf (Entries[count++].se_Entry, "Processes   : %3ld", processes);
  573.  
  574.  
  575.   sprintf (Entries[count++].se_Entry, "Libraries   : %3ld",
  576.        CountNodes (&SysBase->LibList));
  577.  
  578.   /*
  579.    * GMD
  580.    */
  581.   sprintf (Entries[count++].se_Entry, "Devices     : %3ld",
  582.        CountNodes (&SysBase->DeviceList));
  583.  
  584.   sprintf (Entries[count++].se_Entry, "Ports       : %3ld",
  585.        CountNodes (&SysBase->PortList));
  586.  
  587.   sprintf (Entries[count++].se_Entry, "Volumes     : %3ld",
  588.        CountDevices (LDF_VOLUMES));
  589.  
  590.   sprintf (Entries[count++].se_Entry, "Assigns     : %3ld",
  591.        CountDevices (LDF_ASSIGNS));
  592.  
  593.   sprintf (Entries[count++].se_Entry, "Fonts       : %3ld",
  594.        CountNodes (&GfxBase->TextFonts));
  595.  
  596.   sprintf (Entries[count++].se_Entry, "Resources   : %3ld",
  597.        CountNodes (&SysBase->ResourceList));
  598.  
  599.   sprintf (Entries[count++].se_Entry, "Windows     : %3ld",
  600.        CountIntuiObjects ((int) WINDOWS));
  601.  
  602.   sprintf (Entries[count++].se_Entry, "Screens     : %3ld",
  603.        CountIntuiObjects ((int) SCREENS));
  604.  
  605.   CreateEntryList (NO_SORT, 0);
  606.  
  607. /*
  608.    GMD
  609.    PrintInfo ("Systeminfo read", SPEAK, 0);
  610.  */
  611.   return;
  612. }
  613.